package com.alvis.media.controller.admin;

import com.alvis.media.base.BaseApiController;
import com.alvis.media.base.RestResponse;
import com.alvis.media.constant.UserConstant;
import com.alvis.media.domain.User;
import com.alvis.media.domain.other.KeyValue;
import com.alvis.media.service.AuthenticationService;
import com.alvis.media.service.UserEventLogService;
import com.alvis.media.service.UserService;
import com.alvis.media.utility.PageInfoHelper;
import com.alvis.media.viewmodel.admin.user.*;
import com.github.pagehelper.PageInfo;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.io.FileInputStream;
import java.util.Date;
import java.util.List;
import java.util.UUID;


@RestController("AdminUserController")
@RequestMapping(value = "/api/admin/user")
@AllArgsConstructor
public class UserController extends BaseApiController
{
    // DI/IoC
    @Autowired
    private  UserService userService;

    @Autowired
    private  UserEventLogService userEventLogService;

    @Autowired
    private  AuthenticationService authenticationService;

    /**
     * 新增用户 和 修改/编辑用户 功能（如果有用户表的主键值就是编辑用户）
     * @param model  用户在前台页面输入的数据，传递到后台
     * @return RestResponse<User> 响应数据给前台页面
     */
    @RequestMapping(value = "/edit", method = RequestMethod.POST)
    public RestResponse<User> edit(@RequestBody @Valid UserCreateVM model)
    {
        // 检查用户名是否为空
        if (StringUtils.isBlank(model.getUserName()))  // 立即结束程序return
        {
            return new RestResponse<User>(UserConstant.USER_NAME_NOT_ALLOW_NULL, "用户名不能为空");
        }
        
        // 新增用户
        if (model.getId() == null)  
        {
            // 检查用户名是否已存在
            User queryUser = userService.getUserByUserName(model.getUserName());
            if (queryUser != null)
            {
                return new RestResponse<User>(UserConstant.USER_ALREADY_EXISTS, "用户已存在");
            }
            
            // UserCreateVM model ---> User user
            User user = modelMapper.map(model, User.class);
            user.setUserName(model.getUserName()); // 用户名称
            user.setUserUuid(UUID.randomUUID().toString()); // 用户UUID
            String pwdEncode = authenticationService.pwdEncode(model.getPassword());
            user.setPassword(pwdEncode); // 用户密码要加密
            user.setRealName(model.getRealName()); // 真实姓名
            user.setUserLevel(model.getUserLevel()); // 用户等级

            // 明确设置新增用户为未删除状态，确保在用户列表中显示
            user.setDeleted(false);
            // 设置用户状态
            user.setStatus(model.getStatus() != null ? model.getStatus() : UserConstant.USER_STATUS_ENABLE);
            user.setCreateTime(new Date());   // 设置新增用户的时间
            userService.insertByFilter(user);
            return RestResponse.ok(user);
        }
        // 编辑用户
        else 
        {
            // 检查用户是否存在
            User existingUser = userService.getUserById(model.getId());
            if (existingUser == null)
            {
                return RestResponse.fail(404, "用户不存在");
            }
            
            // 检查用户名是否被其他用户占用
            User queryUser = userService.getUserByUserName(model.getUserName());
            if (queryUser != null && !queryUser.getId().equals(model.getId()))
            {
                return new RestResponse<User>(UserConstant.USER_ALREADY_EXISTS, "用户名已存在");
            }
            
            // 保留原密码，只在提供新密码时更新
            String password = existingUser.getPassword();
            if (StringUtils.isNotBlank(model.getPassword())) {
                password = authenticationService.pwdEncode(model.getPassword());
            }
            
            // 创建更新对象，避免覆盖不需要更新的字段
            User updateUser = new User();
            updateUser.setId(model.getId());
            updateUser.setUserName(model.getUserName());
            updateUser.setPassword(password);
            updateUser.setRealName(model.getRealName());
            updateUser.setUserLevel(model.getUserLevel());
            updateUser.setStatus(model.getStatus());
            // 保留原删除状态，确保不会意外修改
            updateUser.setDeleted(existingUser.getDeleted());
            // 更新修改时间
            updateUser.setModifyTime(new Date());
            
            // 执行更新
            int updateResult = userService.updateByIdFilter(updateUser);
            if (updateResult <= 0) {
                return RestResponse.fail(500, "更新用户信息失败");
            }
            
            // 返回更新后的用户信息
            return RestResponse.ok(updateUser);
        }
    }

    /**
     * 删除用户信息（只改数据库表的标记位，不是真的删除数据）
     * @param userId 根据普通用户编号去查询用户信息，然后修改用户是否删除的标志位
     * @return RestResponse 删除后的JSON数据
     */
    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
    public RestResponse delete(@PathVariable Integer id)
    {
        // 根据用户编号查询某个用户信息
        User user = userService.getUserById(id);

        // 不真正的删除用户信息，而是改用户是否删除的标志位
        user.setDeleted(true);

        // 真正的修改是否用户删除的标志位
        int updateOne = userService.updateByIdFilter(user);

        //  int updateOne = userService.deleteById(userId); // NO
        // return RestResponse.ok(updateOne); // NO
        return RestResponse.ok(updateOne);
    }

    /**
     * 启用/禁用代码
     * @param id 要启用/禁用的某条用户记录的主键（用户编号）值 修改T_USER表中status 1-启用  2-禁用
     * @return 响应对应的JSON数据给页面
     */
    @RequestMapping(value = "/changeStatus/{id}", method = RequestMethod.POST)
    public RestResponse<Integer> changeStatus(@PathVariable Integer id)
    {
        // 根据用户编号查询某个用户信息
        User user = userService.getUserById(id);
        
        if (user == null) {
            return RestResponse.fail(404, "用户不存在");
        }

        // 实际开发中不允许硬编码 1 2 这样的值写死
        Integer newUserStatus = user.getStatus() == UserConstant.USER_STATUS_ENABLE ? UserConstant.USER_STATUS_DISABLE : UserConstant.USER_STATUS_ENABLE ;
        user.setModifyTime(new Date()); // 更新用户修改时间
        user.setStatus(newUserStatus);  // 更新用户状态
        
        // 先尝试更新用户状态
        int updateResult = userService.updateByIdFilter(user);
        
        // 检查更新是否成功
        if (updateResult <= 0) {
            return RestResponse.fail(500, "更新用户状态失败");
        }
        
        // 清除缓存（如果使用了缓存）
        // 这里不直接调用缓存清除方法，因为updateByIdFilter方法已经有@CacheEvict注解

        return RestResponse.ok(newUserStatus); // 把修改后的用户状态发送页面
    }

    @RequestMapping(value = "/page/list", method = RequestMethod.POST)
    public RestResponse<PageInfo<UserResponseVM>> pageList(@RequestBody UserPageRequestVM model)
    {
        // 调试信息：打印查询条件
        System.out.println("查询条件 - userName: " + model.getUserName() + ", role: " + model.getRole());
        
        // 直接查询所有未删除的用户，不使用分页条件进行测试
        List<User> allActiveUsers = userService.getUsers();
        System.out.println("查询到的所有活跃用户数量: " + allActiveUsers.size());
        
        // 正常的分页查询
        PageInfo<User> userPageInfo = userService.userPage(model);
        System.out.println("分页查询结果数量: " + userPageInfo.getSize() + ", 总数量: " + userPageInfo.getTotal());

        // 将PageInfo<User> userPageInfo类型 --> PageInfo<UserResponseVM>类型
        PageInfo<UserResponseVM> userResponseVMPageInfo = PageInfoHelper.copyMap(userPageInfo, (d) -> UserResponseVM.from(d));
        return RestResponse.ok(userResponseVMPageInfo);
    }


    @RequestMapping(value = "/event/page/list", method = RequestMethod.POST)
    public RestResponse<PageInfo<UserEventLogVM>> eventPageList(@RequestBody UserEventPageRequestVM model) {

        return RestResponse.ok();
    }

    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
    public RestResponse<UserResponseVM> select(@PathVariable Integer id) {
        // 根据用户ID查询用户信息
        User user = userService.getUserById(id);
        if (user == null) {
            // 使用正确的参数格式：状态码和错误信息
            return RestResponse.fail(404, "用户不存在");
        }
        // 转换为响应视图模型
        UserResponseVM userVm = UserResponseVM.from(user);
        return RestResponse.ok(userVm);
    }

    @RequestMapping(value = "/current", method = RequestMethod.POST)
    public RestResponse<UserResponseVM> current() {
        User user = getCurrentUser();
        UserResponseVM userVm = UserResponseVM.from(user);
        return RestResponse.ok(userVm);
    }




    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public RestResponse update(@RequestBody @Valid UserUpdateVM model) {

        return RestResponse.ok();
    }


    @RequestMapping(value = "/selectByUserName", method = RequestMethod.POST)
    public RestResponse<List<KeyValue>> selectByUserName(@RequestBody String userName) {

        return RestResponse.ok();
    }



    @RequestMapping(value = "/getUserDetailByUserId/{id}", method = RequestMethod.POST)
    public RestResponse<UserResponseVM> getUserDetailByUserId(@PathVariable Integer id) {

        return RestResponse.ok();
    }
}
